Active Image Tagging

ABSTRACT

Methods and systems for active image tagging are usable to build large datasets of tagged images by combining manual tagging by a user and automatic tagging by a computing device based on the manual tagging. Such tags may be used to effectively sort, organize, link, and search for images within large datasets of images. Additionally, the active image tagging may be configured to utilize a tagging game where multiple users manually tag images by playing a game on a computing device.

BACKGROUND

With rapid advances in digital storage devices, networks, and data compression techniques, the volume of digital images throughout the world has been ever growing and rapidly expanding. Additionally, due to the widespread household use of personal computers and the World Wide Web (Web), digital images are regularly uploaded, downloaded, shared, and searched for among Web users. Thus, it is no surprise that the Web has become an enormous repository of data including, in particular, digital images. To effectively manage this voluminous amount of digital images, a promising approach is to annotate them with keywords.

Concept labeling and ontology-free tagging (tagging) are the two typical manners of image annotation. Concept labeling involves presenting an image and a corresponding set of fixed keywords to a user and allowing the user to determine each keyword's relevance. On the other hand, tagging involves allowing users to create image tags independent of any domain-specific rules. However, despite extensive research, efforts have been mainly dedicated towards advancing concept labeling. Unfortunately, automatic image labeling algorithms are still far from satisfactory and manual labeling is rather labor-intensive. In contrast, however, tagging offers more freedom to users and provides a better experience during manual annotation.

Unfortunately, adequate tools do not exist for effectively and/or efficiently tagging digital images on the Web. Existing tagging tools merely provide manual tagging scenarios.

BRIEF SUMMARY

This summary is provided to introduce simplified concepts for active image tagging, which are further described below in the Detailed Description. This summary is not intended to identify essential features of the claimed subject matter, nor is it intended for use in determining the scope of the claimed subject matter. Generally, the active image tagging described herein involves combining manual tagging with automatic sample selection and tag prediction to actively tag digital images that exist on the Web.

In one implementation, active image tagging may be effectuated by iteratively selecting a file stored in memory, providing the file to a user for manual tagging, receiving a user-tagged file in return, and storing the user-tagged file in memory. Additionally, a tag for another file may be created by predicting a tag for the other file based on the user-tagged file, and the other file with the newly predicted tag may also be stored in the memory. The files may be, for example, image files and they may be selected from a subset of data. Moreover, in some examples, an informativeness measure made up of an ambiguity measure, a citation measure, and/or a diversity measure may be used to select the files for manual tagging.

In another implementation, an active image tagging method may iteratively select a file, from a dataset or a subset of the dataset, provide the file to a file tagging game, receive a game-tagged file from the tagging game, and store the game-tagged file in memory. Additionally, in some examples, a tag for another file may be predicted based on the game-tagged file, and the other file may be stored in the memory. Additionally, in some examples, the method may host the file tagging game, thus, providing the file to one or more users and receiving, and also storing, the game-tagged files only after at least two game participants agree on a tag for the file.

In yet another implementation, an active image tagging system may be configured to iteratively select an image file from a subset of data stored in memory, provide the selected image file to a user for manual tagging, and automatically predict image tags for other images based on the user-tagged images until no untagged images remain in the subset. Additionally, in some examples, the system may be further configured to provide the selected image to an image tagging game for manual tagging. Furthermore, in some examples, the system may be configured to base image selection on an informativeness measure, which may be an ambiguity measure, a citation measure, and/or a diversity measure, for example.

BRIEF DESCRIPTION OF THE DRAWINGS

The detailed description is set forth with reference to the accompanying figures. In the figures, the left-most digit(s) of a reference number identifies the figure in which the reference number first appears. The use of the same reference numbers in different figures indicates similar or identical items.

FIG. 1 is a block diagram illustrating an example of active image tagging.

FIG. 2 is a flowchart illustrating details of the active image tagging of FIG. 1.

FIG. 3 is a block diagram of a computer environment showing an illustrative system in which active image tagging can be implemented.

FIG. 4 is a block diagram illustrating an example of active image tagging using a manual tagging game.

FIG. 5 is a flowchart illustrating details of the active image tagging of FIG. 4.

DETAILED DESCRIPTION Overview

This disclosure describes active image tagging. In particular, systems and iterative methods are presented for selecting an image from a subset of a dataset of image files, providing the image to a user for manual tagging, receiving the manually tagged image, storing the manually tagged image in the subset, predicting tags for untagged images in the subset, and storing the newly tagged images in the subset. In some examples the iterative process may continue until no untagged images remain in the subset. Additionally or alternatively, new subsets may be iteratively created that contain other untagged images from the data set, such that the entire process may continue until all images in the data set have been tagged. In other examples, less than all images in a dataset or a subset may be tagged.

As discussed above, image annotation is essential for effectively managing the ever growing volume of digital images that can be found on the Web. However, automatic annotation algorithms are ineffective for large datasets and manual concept labeling is time consuming, restrictive (due its inherent lack of user freedom), and often times boring. These problems, and the need for accurate image tagging, are compounded by the ever increasing size of the Internet. Accordingly, there is a need for active image tagging systems and methods that are robust enough to effectively, accurately, and efficiently tag a large amount of digital image data.

The techniques described in this disclosure may be used for effectively solving the foregoing problems by selecting a sample of the most informative images within a dataset of digital images, providing the images from the sample to a user for manual tagging, and predicting tags for other images in the dataset based on the user-defined tags. Additionally, tagging games, such as the Extra Sensory Perception (ESP) game or other game scenarios, may be used to encourage or enhance the manual tagging process. For example, a set of users may be presented the same image at the same time in a timed-game format such that they are awarded points for quickly providing image tags that match with the other user's provided tags. In other words, a first and second user may be awarded a specific point value when, and if, they each independently enter the same tag for a specific image within the allotted time. Once the users enter matching tags, the entered tag may be stored as a game-defined tag for that image.

Selecting a sample of images from the dataset entails utilizing pre-defined selection criteria to appropriately create effective samples, or subsets, of images. The pre-defined selection criteria may include a citation measure which defines the number of images neighboring a given image, an ambiguity measure which defines the similarities between tags of each neighboring image, and/or a diversity measure which defines the difference between the tags of each file in a sample and the tag of a given image. The application also discloses a nested iterative process for image tagging, which may begin with sample selection based on these criteria and may end when all data in the dataset have been tagged. Additionally, once the sample is selected, an iterative process may begin by providing the sample to a user, or group of users, and may end when all data in the sample has been tagged.

FIG. 1 is an illustrative block diagram illustrating active image tagging 100. By way of example only, a dataset 102 may contain digital images stored in a memory on a computing device (not shown) such as a personal computer, Web server, or the like. Dataset 102 may be made up of tagged data 104 and/or untagged data 106. Both tagged data 104 and untagged data 106 may comprise digital image files, digital video files, digital music files, or any type of digital file that may be tagged with annotations. For purposes of discussion only, and not limitation, this disclosure will hereinafter refer to all data files as image files. In some implementation, for example, the dataset 102 may contain only tagged images 104, only untagged images 106, or a combination of both tagged images 104 and untagged images 106.

In one implementation, sample selection 108 is performed on the untagged images 106 of the dataset 102 in order to select a subset of images to be provided to a user 110. By way of example only, and not limitation, sample selection 108 may comprise calculating an ambiguity measure, a citation measure, a diversity measure, or combinations of the like, for each image of the untagged images 106 and/or the dataset 102. Also by way of example only, sample selection 108 may provide the subset of images to the user 110 via a network interface and/or a display of a client device. That is, the user 110 may view the images on a display of a client device connected directly to the memory containing the dataset 102 or the dataset 102 may reside on a Web server, or other network server, that is remote to the client device.

In one implementation, during manual tagging 112, the user 110 may provide ontology-free tags for the data file(s) (hereinafter image(s)) 114(1)-(N) that are presented to them. In one implementation, the user 105 may be required to provide tags for all images 114(1)-(N) in the subset of untagged images 106. However, in another implementation, the user 110 may provide tags for only some images 114(1)-(N) in the subset. Once manual tagging 112 has completed the user-tagged images 114(1)-(N) may be transmitted back to the dataset 102 for automatic tagging 116.

By way of example only, during automatic tagging 116, tag prediction 118 may iteratively predict new tags for all, or some, of the images in the dataset 102. In one implementation, tag prediction 118 may predict tags for untagged images 106, thus increasing the number of tagged images 104. In this way, untagged images 106 are transformed into tagged images 104 (represented by dotted line 120). In another implementation, tag prediction 118 may automatically tag all images in the dataset 102, including already tagged images. In this way, new tags may be predicted for already tagged images 104 and incorrectly predicted tags may be corrected. By way of example, and not limitation, the iterative process may repeat until all images in the dataset 102 are tagged or until all images in the dataset 102 are correctly tagged; that is, until every image tag is predicted correctly. In one implementation, after the iterative automatic tagging 116 ends, new untagged images 106 may be added to the dataset 102. In this case, sample selection 108 may create new subsets to be sent to a user 110 for another round of manual tagging.

FIG. 2 is a flow diagram of one illustrative method 200 for implementing the active image tagging 100 of FIG. 1. As discussed above, active image tagging 100 may be responsible for iteratively, and automatically, tagging images within a dataset based on user-provided tags. In this particular implementation, the method 200 may begin at block 202, in which the method 200 may maintain image files in a memory. For example, as shown in FIG. 1, the image files may be stored in a dataset 102. By way of example only, the method 200 may determine whether any untagged images exist in the dataset 102 at decision block 204. If no untagged images exist in the dataset 102, meaning that all images have been tagged, method 200 may continue to maintain the image files in memory at block 202. Alternatively, decision block 204 may determine whether all tagged files in the dataset 102 are correctly tagged. If so, method 200 may continue to maintain the image files as if all the images are tagged.

On the other hand, if the method 200 determines that untagged files exist in the dataset 102, or some image files are incorrectly tagged, the method 200 may create a subset of image files at block 206 prior to selecting files at block 208. In one implementation, however, the method 200 may omit the subset creation of block 206 and proceed directly to selecting files at block 208.

By way of example, and not limitation, the method 200 may then provide the selected files to a user, or group of users, at block 210. The user may perform ontology-free tagging, or even image labeling, to annotate the image files. This step may be performed independent of the method 200, or the method 200 may effectuate the manual tagging implementation by causing display of the image on a display with a text field for the user and receiving the annotation directly. In one implementation, at block 212, the method 200 may receive the user-tagged image file and then store the user-tagged image files in the subset at block 214. In some instances, however, no subset is created and the user-tagged image files may then be stored in the dataset 102 rather than in the subset. When a subset is used, at decision block 216, the method 200 determines whether untagged images exist in the subset. If untagged images exist in the subset, meaning at least some of the images in the subset have yet to be manually tagged, the method 200 may select additional files from the subset at block 208. Thus, the method 200 may iteratively repeat these steps until all images in the subset are manually tagged by a user.

On the other hand, if no untagged images exist in the subset, meaning all images in the subset have been manually tagged by a user, the method 200 may predict tags for the other images in the dataset 102 at block 218. In this way, the method 200 may perform the automatic tagging 116 of FIG. 1. By way of example only, at block 220, the method 200 may store the newly tagged images in the memory. For example, the other tagged images may be stored in the dataset 102 of FIG. 1. Following block 220, the method 200 may continue to determine whether untagged files exist in the dataset 102 at decision block 204 once again. In this way, the active image tagging method 200 may be iteratively performed until all images in the dataset 102 are tagged.

FIGS. 1 and 2 provide simplified examples of suitable methods for active image tagging according to the present disclosure. However, other configurations are also possible. For example, while manual tagging 112 is shown with one user 110, this may be performed by multiple independent users or by groups of users. Additionally, image file(s) 114(1)-(N) may comprise multiple tags for each image file 114(1)-(N).

Illustrative Active Sample Selection and Tag Prediction

As shown in FIG. 1, sample selection and tag prediction are two main components of active image tagging. To that end, several calculations may be helpful using the following variables: C, the set of all images;

, the set of all manually tagged images; and U, the set of all yet-to-be-tagged images. Given n images where C={x₁, x₂, . . . , x_(n)}, the target may be to provide tags for all images. Supposing that the first l images have been manually tagged,

={x₁, x₂, . . . , x₁} and U={x₁₊₁, x₁₊₂, . . . , x_(n)}. For each x_(i) in

, it may be associated with a set of tags, T_(i) where T is the global tag set and T={t₁, t₂, . . . , t_(m)} (i.e., there are m tags in all). Thus, the sample selection and tag prediction components may move a batch of samples from U to

and predict the tags of the samples in U.

As discussed above, a sample selection of untagged images may be provided to a user, or group of users, for manual tagging based on an informativeness measure. In other words, the most informative images may be selected from the dataset, or a subset of the dataset, for manual tagging. In one implementation, the informativeness measure may be based on an ambiguity measure, a citation measure, a diversity measure, combinations thereof, or the like.

By way of example only, the ambiguity measure of each image may be determined by analyzing the respective tags of each neighboring image within the dataset or subset. For example, there may be k_(i) manually tagged images in the neighborhood of x_(i), and there may be m_(i) tags associated with these images. Thus, the appearance probabilities of each tag may be denoted as P₁, P₂, . . . , P_(m) _(i) . An appearance probability defines the likelihood of that tag appearing in the neighborhood. For example, if there are ten tagged samples in the neighborhood and two of them contain the tag “apple,” then its appearance probability will be 1/5. Based on these parameters, the ambiguity measure of x_(i) may be defined as:

$\begin{matrix} {{{ambiguity}\mspace{14mu} \left( x_{i} \right)} = {1 - \frac{k_{i}}{K} - {\frac{k_{i}}{K}\frac{\begin{matrix} {{\sum\limits_{j = 1}^{m_{i}}{P_{j}\log \; P_{j}}} +} \\ {\left( {1 - P_{j}} \right){\log \left( {1 - P_{j}} \right)}} \end{matrix}}{m_{i}}}}} & (1) \end{matrix}$

The citation measure of an image may be defined as the number of images that has taken each image as a neighbor, and may be described as:

$\begin{matrix} {{{citation}\mspace{14mu} \left( x_{i} \right)} = \frac{\sum\limits_{j = 1}^{n}{I\left( {x_{j} \in N_{i}} \right)}}{n}} & (2) \end{matrix}$

where I(.) is the indicator function (I(true)=1 and I(false)=0) and N is the k-nearest neighborhood of x_(i). This criterion aims to select the images with high citation values, which may help predict the tags of more images.

The diversity criterion may enforce the selected samples to be diverse and may keep a variety of images from being constrained within restricted areas by determining the difference between tags of images in a sample from the tag of each other image in the sample. Given a kernel K, the angle between the feature vectors of two samples x_(i) and x_(j) in feature space may be defined as:

$\begin{matrix} {{\cos \left( {{< x_{i}},{x_{j} >}} \right)} = \frac{{K\left( {x_{i},x_{j}} \right)}}{\sqrt{{K\left( {x_{i},x_{j}} \right)}{K\left( {x_{i},x_{j}} \right)}}}} & (3) \end{matrix}$

and thus, adopting a Gaussian kernel, the diversity measure for sample x_(i) can be estimated as:

$\begin{matrix} {{{diversity}\mspace{14mu} \left( x_{i} \right)} = {1 - {\max\limits_{x_{j} \in \mathcal{L}}{\exp\left( {- \frac{{{x_{i} - x_{j}}}^{2}}{\sigma^{2}}} \right)}}}} & (4) \end{matrix}$

By way of example only, and not limitation, the informativeness measure may be a linear combination of the above measures. In this way, the sample selection may be performed based on the following equation:

informativeness(x _(i))=α×ambiguity(x _(i))+β×diversity(x _(i))+(1−α−β)×citation(x _(i))  (5)

however, other combinations, including non-linear combinations, of the ambiguity measure, diversity measure, and citation measure may also be used to calculate the informativeness measure.

In one implementation, tag prediction may be performed with two random walk processes. Image and tag graphs may be constructed (i.e., similarity matrices) and, as noted above, N_(i) is the k-nearest neighborhood of x_(i). Additionally, an image affinity matrix W^(I) may be constructed. W^(I) may be defined by:

$\begin{matrix} {W_{ij}^{I} = {\exp\left( {- \frac{{{x_{i} - x_{j}}}^{2}}{\sigma^{2}}} \right)}} & (6) \end{matrix}$

if i≠j and x_(j)εN_(i), and W_(ii) ^(l) is set to 0.

A tag graph may be constructed by mining data from a Web site or a Web server and the distance between two tags t_(i) and t_(j) may be calculated as follows:

$\begin{matrix} {{d\left( {t_{i},t_{j}} \right)} = {\exp \left( {- \frac{{\max \left( {{\log \; {f\left( t_{i} \right)}},{\log \; {f\left( t_{j} \right)}}} \right)} - {\log \; {f\left( {t_{i},t_{j}} \right)}}}{{\log \; G} - {\min \left( {{\log \; {f\left( t_{i} \right)}},{\log \; {f\left( t_{j} \right)}}} \right)}}} \right)}} & (7) \end{matrix}$

where f(t_(i)) and f(t_(i)) are the numbers of images containing tag t_(i) and t_(j) respectively, f(t_(i), t_(j)) is the number of images containing both t_(i) and t_(j), and G is the total number of images on the Web site or Web server. In one implementation, these numbers can be obtained by performing a tag-based search on the Web site or Web server. Thus, the concurrence similarity between t_(i) and t_(j) is then defined as:

W _(ij) ^(T)=exp (−d(t _(i) ,t _(j)))  (8)

In another implementation, however, the tag graph construction may be performed by other methods, such as by using word similarity calculations or distance based calculations.

By way of example only, a diagonal matrix may be formed based on the image affinity matrix described above and the random walk process may iteratively walk the diagonal matrix until convergence, where F_(ij) may be regarded as the initial relevance score x_(i) with respect to t_(j). After obtaining F, a tag-level random walk may then be performed to refine the relevance scores by leveraging the relationships of the tags. Much like the image-level random walk, the second random walk may iterate until convergence. For each image x_(i), the relevance scores may then be ranked, and then the first r tags may be selected, where r is set to the average number of tags per image in

.

Illustrative Computing Environment

FIG. 3 provides an illustrative overview of one computing environment 300, in which implementations of the disclosure may be implemented. The computing environment 300 may be configured as any suitable computing device capable of implementing an active image tagging system, and accompanying methods, such as, but not limited to those described with reference to FIGS. 1 and 2. By way of example and not limitation, suitable computing devices may include personal computers (PCs), servers, server farms, datacenters, or any other device capable of storing and executing all or part of the active tagging methods.

In one illustrative configuration, the computing environment 300 comprises at least a memory 302 and one or more processing units (or processor(s)) 304. The processor(s) 304 may be implemented as appropriate in hardware, software, firmware, or combinations thereof. Software or firmware implementations of the processor(s) 304 may include computer-executable or machine-executable instructions written in any suitable programming language to perform the various functions described.

Memory 302 may store program instructions that are loadable and executable on the processor(s) 304, as well as data generated during the execution of these programs. Depending on the configuration and type of computing device, memory 302 may be volatile (such as random access memory (RAM)) and/or non-volatile (such as read-only memory (ROM), flash memory, etc.). The computing device or server may also include additional removable storage 306 and/or non-removable storage 308 including, but not limited to, magnetic storage, optical disks, and/or tape storage. The disk drives and their associated computer-readable media may provide non-volatile storage of computer readable instructions, data structures, program modules, and other data for the computing devices. In some implementations, the memory 302 may include multiple different types of memory, such as static random access memory (SRAM), dynamic random access memory (DRAM), and/or ROM.

Memory 302, removable storage 306, and non-removable storage 308 are all examples of computer-readable storage media. Computer-readable storage media includes, but is not limited to, volatile and non-volatile, removable and non-removable media implemented in any method or technology for storage of information such as computer-readable instructions, data structures, program modules or other data. Memory 302, removable storage 306, and non-removable storage 308 are all examples of computer storage media. Additional types of computer storage media that may be present include, but are not limited to, phase change memory (PRAM), SRAM, DRAM, other types of RAM, ROM, electrically erasable programmable read-only memory (EEPROM), flash memory or other memory technology, compact disc read-only memory (CD-ROM), digital versatile disks (DVD) or other optical storage, magnetic cassettes, magnetic tape, magnetic disk storage or other magnetic storage devices, or any other medium which can be used to store the desired information and which can be accessed by the server or other computing device. Combinations of any of the above should also be included within the scope of computer-readable storage media.

The computing environment 300 may also contain communications connection(s) 310 that allow the computing environment 300 to communicate with a stored database, another computing device or server, user terminals, and/or other devices on a network. The computing environment 300 may also include input device(s) 312 such as a keyboard, mouse, pen, voice input device, touch input device, etc., and output device(s) 314, such as a display, speakers, printer, etc.

Turning to the contents of the memory 302 in more detail, the memory 302 may include an operating system 316 and one or more application programs or services for implementing active image tagging including an image file selection module 318. The image file selection module 318 may be configured to perform the sample selection described above with reference to FIGS. 1 and 2. For example, the image file selection module 318 may be configured to select images from a dataset or subset of images based on an informativeness measure.

The memory 302 may further include a manual image file tagging module 320. The manual image file tagging module 320 may be configured to provide the selected images to a user, or group of users, for manual tagging. In one example, the selected images may be provided to a display device of a client device. In another example, the selected images to a display device of a host computer, such as the computing environment 300. As discussed above, manual image tagging is but one way to provide image annotations. Additionally, the results of the manual image tagging may be provided by the manual image file tagging module 320 for processing by the active image tagging computing environment 300. In one implementation, the manual image file tagging module 320 may provide an image, or images, to a user for entering user-specified image tags. In another implementation, the manual image file tagging module 320 may provide an image, or images, to two or more users playing an image tagging game.

The memory 302 may further include an automatic image file tagging module 322 and an iteration module 324. As discussed above, the automatic image file tagging module 322 may be configured to predict tags for untagged images in a dataset based on the results of the manual image file tagging module 320. In one implementation, the automatic image file tagging module 322 may be responsible for automatically tagging all images in the dataset. In another implementation, the automatic image file tagging module 322 may be responsible for tagging all images stored in a memory. In yet another implementation, the automatic image file tagging module 322 may only be responsible for tagging untagged images from within a subset of a dataset. Additionally, in some implementations, the automatic image file tagging module 322 may predict tags for untagged images based on the two random walks described above. Yet, in other implementations, the automatic image file tagging module 322 may predict tags based on other methods.

The iteration module 324 may be configured to control multiple iterations of the active image tagging methods 100 and 200 described in relation to FIGS. 1 and 2. In one implementation, the iteration module 324 may be configured to control iterations of the entire image tagging process described above. In this way, the active image tagging methods may proceed iteratively until all images in the dataset are tagged. In other implementations, the iteration module 324 may be configured to control iterations of the tag prediction processes described above. In this way, the active image tagging methods may iteratively, and automatically, tag the untagged images based on the user-provided tags only after the automatic tagging has completed.

Illustrative Active Image Tagging with Manual Tagging Game

FIG. 4 is an illustrative block diagram illustrating active image tagging with a manual image tagging game 400. Similar to that described with reference to FIG. 1, and by way of example only, a dataset 402 may contain digital images stored in a memory of a computing device such as a personal computer, Web server, or the like. Dataset 402 may be made up of tagged data 404 and/or untagged data 406. As discussed above, both tagged data 404 and untagged data 406 may comprise digital image files, digital video files, digital music files, and/or any type of digital file that may be tagged with annotations. In one implementation, for example, the dataset 402 may contain tagged images 404, such as after completion of active image tagging with manual image tagging game 400. In another implementation, the dataset 402 may contain untagged images 406, such as prior to implementing active image tagging with manual tagging game 400. Additionally, the dataset 402 may contain both tagged images 404 and untagged images 406 simultaneously, such as during implementation of active image tagging with manual tagging game 400.

By way of example only, in one implementation, sample selection 408 is performed on the untagged images 406 of the dataset 402 in order to select a subset of images to be provided to a manual tagging game 410. By way of example only, and not limitation, sample selection 408 may comprise calculating an ambiguity measure, a citation measure, a diversity measure, or combinations of the like, for each image of the untagged images 406 and/or the dataset 402. Also by way of example only, sample selection 408 may provide the subset of images to the manual tagging game 410 via a network interface and/or a display device.

The manual tagging game 410 may comprise two or more users 412(1), 412(2), . . . , 412(N). The users 412(1)-(N) may be presented with untagged images 406 or tagged images 404 (with correct or incorrect tags) for tagging. In one implementation, the manual tagging game 410 may provide the users 412(1)-(N) with one image 414 of the image file(s) 414(1)-(N) selected during sample selection 408 for a specific amount time. In an example with two users 412(1)-(2), if both users 412(1) and 412(2) enter the same tag for a given image 414 within the allotted time, the manual tagging game 410 may store the entered tag as the tag for the given image 414. On the other hand, if the two users 412(1) and 412(2) enter tags different than each other, the manual tagging game 410 may store the entered tags as possible tags, may store the tags as incorrect tags, or may discard the tags altogether. If no match between the two users 412(1) and 412(2) entered tags occurs during the allotted time, the presented image 414 may not be tagged and may return into the sample, or subset, as an untagged image 406. In one implementation, once all the images 414(1)-(N) are manually tagged by the manual tagging game 410 the game-tagged images 414(1)-(N) may be transmitted back to the dataset 402 for automatic tagging 416.

By way of example only, and not limitation, during automatic tagging 416, tag prediction 418 may iteratively predict new tags for all, or some, of the images in the dataset 402. In one implementation, tag prediction 418 may only predict tags for untagged images 406, thus increasing the number of tagged images 404. In this way, untagged images 406 are transformed into tagged images 404 (represented by dotted line 420). In another implementation, tag prediction 418 may automatically tag all images in the dataset 402, including already tagged images. As discussed with reference to FIG. 1, in this way, new tags may be predicted for already tagged images 404 and incorrectly predicted tags may be corrected. Also, as discussed above, and by way of example only, the iterative process may repeat until all images in the dataset 402 are tagged or until all images in the dataset 402 are correctly tagged; that is, until every image tag is predicted correctly. In one implementation, after the completion of iterative automatic tagging 416, new untagged images 406 may be added to the dataset 402. In this way, sample selection 408 may create new samples to be sent to the manual tagging game 410 for additional rounds of manual tagging.

FIG. 5 is a flow diagram of one illustrative method 500 for implementing the active image tagging with manual tagging game 400 of FIG. 4. As discussed above, active image tagging with manual tagging game 400 may be responsible for iteratively, and automatically, tagging images within a dataset based on game-provided tags. In this particular implementation, the method 500 may begin at block 502 in which the method 500 may maintain image files in a memory. For example, as seen in FIG. 4, the image files may be stored in a dataset 402. At decision block 504, the method 500 determines whether any untagged images exist in the dataset 402. If no untagged images exist in the dataset 402, meaning that all images may have been tagged, method 500 may continue to maintain the image files in memory at block 502. Alternatively, decision block 504 may determine whether all tagged files in the dataset 402 are correctly tagged. If so, method 500 may continue to maintain the image files similar to when all the images are tagged.

On the other hand, if the method 500 determines that untagged files exist in the dataset 402, or some image files are incorrectly tagged, the method 500 may create a subset of image files at block 506 prior to selecting files at block 508. In one implementation, however, the method 500 may omit the subset creation of block 506 and proceed directly to selecting files at block 508.

By way of example, and not limitation, the method 500 may then provide the selected files to users of a tagging game at block 510. The users may perform ontology-free tagging, or even image labeling, to annotate the image files. This step may be performed independent of the method 500, or the method 500 may effectuate the manual tagging implementation by displaying the image on a display with a text field for the users and receiving the annotations directly. By way of example only, and as discussed above with reference to FIG. 4, the image tagging game may store tags for images based on matched tags of the game players. Thus, by way of example only, the method 500 may determine whether the game users agree on a tag for a given image at decision block 512. In one example, if the users do not agree on a tag for a given image, the method 500 may provide another image from the sample selection at block 510. In this way, the method 500 may iteratively present images to the game players until they agree on a tag.

On the other hand, if the users agree on a tag for a given image the method 500 may receive the tagged files from the users, and/or the game, at block 514 and then store the game-tagged image files in the subset at block 516. In one implementation, however, no subset is created and the user-tagged image files may then be stored in the dataset 402 rather than in the subset. When a subset is used, at decision block 518, the method 500 determines whether untagged images exist in the subset. If untagged images exist in the subset, meaning all images in the subset have yet to be manually tagged, the method 500 may proceed to select additional files from the subset at block 508. Thus, the method 500 may proceed iteratively until all images in the subset are manually tagged by the game.

On the other hand, if no untagged images exist in the subset, meaning all images in the subset have been manually tagged by the game, the method 500 may predict tags for the other images in the dataset 402 at block 520. In this way, the method 500 may perform the automatic tagging 416 of FIG. 4. At block 522, the method 500 stores the newly tagged images in the memory. For example, the other tagged images may be stored in the dataset 402 of FIG. 4. By way of example only, following block 522, the method 500 may continue to determine whether untagged files exist in the dataset 402 at decision block 504 once again. In this way, the active image tagging method with manual tagging game 500 may be iteratively performed until all images in the dataset 402 are tagged.

FIGS. 3-5 provide simplified examples of suitable systems and methods for active image tagging with a manual tagging game according to the present disclosure. However, other configurations are also possible. For example, while the manual tagging game 410 is shown with two users 412(1) and 412(2), this may be performed by multiple users 412(1)-(N) playing the same, or different versions, of the manual tagging game 410. Additionally, image file(s) 414(1)-(N) may each comprise multiple tags.

Illustrative methods and systems of active image tagging are described above. Some or all of these systems and methods may, but need not, be implemented at least partially by an architecture such as that shown in FIG. 3. Also, certain acts in the methods need not be performed in the order described, may be rearranged, modified, and/or may be omitted entirely, depending on the circumstances. Also, any of the acts described above with respect to any method may be implemented by a processor or other computing device based on instructions stored on one or more computer-readable storage media. Further, as used herein, computer-readable storage media does not include and should not be construed to cover carrier waves or other types of communication media.

CONCLUSION

Although embodiments have been described in language specific to structural features and/or methodological acts, it is to be understood that the disclosure is not necessarily limited to the specific features or acts described. Rather, the specific features and acts are disclosed as illustrative forms of implementing the embodiments. 

1. A computer-implemented method for active tagging, comprising: performed by one or more processors executing computer-readable instructions: selecting a file stored in a memory; providing the file to a client device for manual tagging by a user of the client device; receiving a tagged file from the client device; storing the tagged file in the memory; predicting a tag for another file based on the tagged file to create another tagged file in the memory; and storing the other tagged file in the memory.
 2. The computer-implemented method of claim 1, wherein the file and the other file comprise image files.
 3. The computer-implemented method of claim 1, wherein selecting a file stored in memory comprises selecting the file from a subset of data.
 4. The computer-implemented method of claim 3, iteratively performing the method until no untagged files exist in the data.
 5. The computer-implemented method of claim 3, iteratively performing the selecting a file, the providing the file, the receiving a tagged file, and the storing the tagged file until no untagged files exist in the subset.
 6. The computer-implemented method of claim 5, iteratively performing the predicting a tag and the storing the other tagged file when no untagged files exist in the subset and subsequent to iteratively performing the selecting a file, the providing the file, the receiving a tagged file, and the storing the tagged file.
 7. The computer-implemented method of claim 3, wherein selecting a file comprises selecting the file from the subset of files based on an informativeness measure.
 8. The computer-implemented method of claim 7, the informativeness measure comprising a citation measure defining a number of files neighboring the file, an ambiguity measure defining a similarity between a tag of each neighboring file and a tag of the file, and/or a diversity measure defining a difference between a tag of each file in a sample and the tag of the file.
 9. The computer-implemented method of claim 1, wherein providing the file to a client device comprises providing the file and a text entry field associated with the file to the client device for displaying to the user.
 10. The computer-implemented method of claim 1, wherein providing the file to a client device for manual tagging by the user comprises transmitting the file through a network interface to a client device connected to a network.
 11. One or more computer-readable storage media, storing processor-executable instructions that, when executed on a processor, perform acts for active tagging, the acts comprising: selecting a file stored in a memory; providing the file to a file tagging game; receiving a tagged file from the file tagging game; storing the tagged file in the memory; predicting a tag for another file in the memory based on the tagged file; and storing the other tagged file in the memory.
 12. The one or more computer-readable storage media of claim 11, wherein the file and the other file comprise image files.
 13. The one or more computer-readable storage media of claim 11, iteratively performing the method until no untagged files exist in the memory.
 14. The one or more computer-readable storage media of claim 11, further comprising hosting the file tagging game.
 15. The one or more computer-readable storage media of claim 14, wherein hosting the file tagging game comprises: providing the file to a plurality of client devices; receiving a game-defined tag associated with the file from each of the plurality of client devices; and storing the game-defined tag with the file in the memory.
 16. The one or more computer-readable storage media of claim 15, wherein the plurality of client devices comprises a first client device and a second client device.
 17. The one or more computer-readable storage media of claim 16, wherein storing the game-defined tag with the file in the memory comprises storing the game-defined tag with the file when the game-defined received from first client device matches the game-defined tag received from the second client device.
 18. A system for iterative active image tagging comprising: memory and a processor; an image file selection module, stored in the memory and executable on the processor, configured to select an image file from a subset of data stored in the memory; a manual image file tagging module, stored in the memory and executable on the processor, configured to provide the selected image file to a client device for a user to create a manually tagged image file to be stored in the memory; an automatic image file tagging module, stored in the memory and executable on the processor, configured to provide automatic image tags to other image files in the subset of data stored in the memory based on the manually tagged image file; and an iteration module, stored in the memory and executable on the processor, configured to iteratively activate the manual image file tagging module and the automatic image file tagging module until tagging is complete.
 19. The system of claim 18, wherein the manual image file tagging module is further configured to provide the selected image file to a second client device for a second user to create the manually tagged image file to be stored in the memory, the first and second client devices being connected through a tagging game and the creation of the manually tagged image file being based on a result of the tagging game.
 20. The system of claim 18, wherein the image file selection module is further configured to select the image file based on an informativeness measure. 